The present invention provides a means and methodology to hedge the scalability problems inherent to conventional code-writing techniques and conventional 3d generation languages. This is to be done by packaging functional software in the form of components—not objects as is currently in vogue. Objects require that their use be preplanned; whereas, components need only be understandable and retrievable to be composed. There have been actual products—first Lisp, then Scheme, and finally Layout. While not the same as this disclosure, nevertheless each of these products has served to show the viability in practice of a component-based approach of the type disclosed herein. Just as gate arrays have supplanted custom ICs where speed is not absolutely critical, so too will component-based software replace custom coding. It is thus vitally important that the military take a renewed look at how they write and verify their complex software products. Much can be improved—including macroeconomic spillover into the civilian sectors.
Related prior methods had inception with machine language, (relocatable) assembly language, 3d, 4th, and 5th generation languages. While the 3d generation languages, which became ubiquitous with the arrival of Fortran, were universal (i.e., unlike the 4th and 5th generation languages), the Turing language is universal too. The point is that universality says nothing about the ease of programming in them. It follows from the works of Chaitin and Kolmogorov that reuse is the way to hedge complexity while maximally verifying component codes. However, prior methods had relocatable code (macros) for the IBM 360 assembler, which gave way to subroutines in Fortran, and later to methods in Java. However, such approaches do not take advantage of component-based capabilities—from indexing to testing to automated synthesis and CASE tools—it is time to take the next step forward.